# friend-service/src/friend_service/main.py（完全同步版）
from fastapi import FastAPI, Depends, HTTPException
import requests  # 替换异步 httpx，用同步 HTTP 客户端
from sqlalchemy.orm import Session  # 同步 Session，替换 AsyncSession
import uvicorn
from signal import SIGINT, SIGTERM
# 去掉 asyncio 导入（不再需要异步线程）
from . import crud, models, schemas
from .database import engine, get_db  # 导入同步 engine 和 get_db
from common.config import settings
from common.http_client import HttpClient  # 确保 HttpClient 是同步版（或替换成 requests）
from common.consul_utils import consul_service  # 引入Consul工具

# 1. 创建数据库表（用同步 engine，和 user-service 一致）
models.Base.metadata.create_all(bind=engine)

app = FastAPI(title="Friend Service")

# 2. 同步 HTTP 客户端依赖（去掉 await，用同步 close）
def get_user_client():
    # 注意：如果 HttpClient 是异步的，需换成同步版（如 requests.Session）
    client = HttpClient(settings.user_service_url)  
    yield client
    client.close()  # 同步关闭，去掉 await

# 3. 健康检查接口（同步，去掉 async）
@app.get("/health", tags=["system"])
def health_check():  # async def → def
    return {"status": "healthy", "service": "friend-service"}

# 4. 添加好友（同步路由：async def → def，db 类型换 Session）
@app.post("/friendships/", response_model=schemas.Friendship)
def create_friendship(
    friendship: schemas.FriendshipCreate,
    db: Session = Depends(get_db),  # AsyncSession → Session
    client: HttpClient = Depends(get_user_client)
):
    # 调用 User 服务验证用户（同步 HTTP 调用，去掉 await）
    for user_id in [friendship.user_id, friendship.friend_id]:
        try:
            # 同步调用：如果用 requests，就是 client.get(...)；如果是同步 HttpClient，直接调用
            client.get(f"/users/{user_id}")  # 去掉 await
        except requests.HTTPError as e:  # 换成 requests 的异常（根据客户端调整）
            if isinstance(e, requests.HTTPError) and e.response.status_code == 404:
                raise HTTPException(status_code=404, detail=f"User {user_id} not found")
            raise HTTPException(status_code=500, detail="Failed to connect to user service")
    
    # 同步调用 crud（crud 函数需改成同步，去掉 await）
    existing = crud.get_friendship(db, friendship.user_id, friendship.friend_id)
    if existing:
        raise HTTPException(status_code=400, detail="Friendship already exists")
    
    return crud.create_friendship(db=db, friendship=friendship)  # 去掉 await

# 5. 获取用户所有好友（同步路由，同上）
@app.get("/users/{user_id}/friends/", response_model=list[schemas.Friendship])
def get_user_friends(
    user_id: int, 
    db: Session = Depends(get_db)  # AsyncSession → Session
):
    return crud.get_friends(db, user_id=user_id)  # 同步 crud，去掉 await

# 6. 同步服务注册/注销（去掉 asyncio.to_thread，直接调用）
def startup_event():  # async def → def
    """服务启动时注册到Consul（同步调用）"""
    consul_service.register_service(
        service_name="friend-service",
        service_port=8002,
        tags=["friend", "microservice"]
    )

def shutdown_event():  # async def → def
    """服务关闭时从Consul注销（同步调用）"""
    consul_service.deregister_service()

# 7. 添加同步事件处理器（无异步）
app.add_event_handler("startup", startup_event)
app.add_event_handler("shutdown", shutdown_event)

if __name__ == "__main__":
    # 启动同步服务（和 user-service 一致）
    uvicorn.run("friend_service.main:app", host="0.0.0.0", port=8002, reload=True)